// 处理cdatas数据(一种情况)
import {useAnalysetStore} from "@/store";

const analyseStatusPage = useAnalysetStore()

export function transformData(inputArray) {
    return inputArray.map(item => {
        // 查找包含“测定结果”的键
        const cgjgKey = Object.keys(item).find(key => key.includes("测定结果"));

        return {
            sample_sn: String(item["样品编号"] ?? item["样品唯一性标识"] ?? ""),  // 兜底为空字符串
            type: String(item["类型"] || ""),
            test_parms: analyseStatusPage.waterForm.tableItem.test_parms,
            cdjg: String(item["最终结果"] ?? (cgjgKey ? item[cgjgKey] : "")) // 先取"最终结果"，否则取找到的"测定结果(单位)"
        };
    });
}

// 提取浓度单位的cdatas
export function transCdata(inputArray) {
    return inputArray.map(item => {
        // 提取 "样品浓度(XXX)" 里的 XXX
        let dw = "";
        const ndKey = Object.keys(item).find(key => key.includes("样品浓度")); // 动态匹配 "样品浓度"

        if (ndKey) {
            const match = ndKey.match(/\((.*?)\)/); // 提取括号内的内容
            dw = match ? match[1] : ""; // 如果匹配成功，取括号内的内容，否则为空
        }

        return {
            sample_sn: String(item["样品编号"] ?? item["样品唯一性标识"] ?? ""),  // 兜底为空字符串
            type: String(item["类型"] || ""),
            cdjg: String(item["最终结果"] ?? item["测定结果"] ?? ""), // 先取"最终结果"，否则取"测定结果"
            dw: dw // 存储括号内的内容
        };
    });
}


//处理插件表头是一行，不带合并单元格
export function processTableData(data) {
    if (!data || data.length < 2) {
        return [];
    }
    // 提取表头
    const headers = data[0].map(item => item.field || "");
    // 处理数据行
    const result = [];
    for (let i = 1; i < data.length; i++) { // 遍历每一行数据
        const values = data[i].map(item => item.field ?? null);
        const rowObject = {};

        headers.forEach((header, index) => {
            if (header.trim()) {
                rowObject[header] = values[index] ?? null;
            }
        });

        result.push(rowObject);
    }
    return result;
}

// 处理具有合并表格的数据，不包括里面又元素、检出限这种
export function processData(data) {
    if (!data || data.length < 2) {
        return [];
    }

    // 提取表头字段
    const headers = [];
    for (let i = 0; i < data[0].length; i++) {
        const field1 = data[0][i]?.field || ""; // 第一行的字段
        const field2 = data[1][i]?.field || ""; // 第二行的字段

        // 优先使用第二行字段，如果为空则使用第一行字段
        const header = (field1 === "默认字段" || field1 === "") ? field2 : field1;

        // 跳过无效字段
        if (header !== "默认字段" && header.trim() !== "") {
            headers.push(header);
        }
    }

    // 处理数据部分
    const result = data.slice(2).map(row => {
        const rowObject = {};
        headers.forEach((header, index) => {
            const cell = row[index];
            rowObject[header] = cell?.field ?? null; // 如果没有值，则默认 null
        });
        return rowObject;
    });

    // 过滤掉空行（所有字段均为 null 的行）
    return result.filter(row =>
        Object.values(row).some(value => value !== null)
    );
};

// cdata里面排除编号为null或者为空字符串的
export const removeNullSampleSN = (data) => {
    return data.filter(item => item.sample_sn !== null && item.sample_sn !== "" && item.sample_sn !== undefined);
};

// cdata里面排除普通样并且排除编号为null的
export const filterValidSamples = (data, targetType = "普通样") => {
    return data.filter(item =>
        item.sample_sn !== null &&
        item.sample_sn !== "" &&
        item.sample_sn !== undefined &&
        item.type === targetType
    );
};

// adata里面排除编号为null或者为空字符串的
export function filterValidSampleAdatas(data) {
    return data.filter(item => item["样品编号"] !== null);
}

//处理一元一次方程公式
export function linearRegression(x, y) {
    if (x.length !== y.length || x.length === 0) {
        throw new Error("x 和 y 数组长度必须相等且非空");
    }

    // 计算均值
    const xMean = x.reduce((sum, val) => sum + val, 0) / x.length;
    const yMean = y.reduce((sum, val) => sum + val, 0) / y.length;

    // 计算斜率 m 和截距 b
    let numerator = 0; // 分子
    let denominator = 0; // 分母

    for (let i = 0; i < x.length; i++) {
        numerator += (x[i] - xMean) * (y[i] - yMean);
        denominator += (x[i] - xMean) ** 2;
    }

    const m = numerator / denominator; // 斜率
    const b = yMean - m * xMean; // 截距

    // 计算相关性系数 R²
    let ssTotal = 0; // 总平方和
    let ssResidual = 0; // 残差平方和
    let ssRegression = 0; // 回归平方和

    for (let i = 0; i < x.length; i++) {
        const yPred = m * x[i] + b; // 预测值
        ssTotal += (y[i] - yMean) ** 2;
        ssResidual += (y[i] - yPred) ** 2;
        ssRegression += (yPred - yMean) ** 2;
    }

    const rSquared = ssRegression / ssTotal; // R²
    let r = Math.sqrt(Math.abs(rSquared)); // 计算 r

    // 根据斜率方向调整 r 的正负号
    if (m < 0) {
        r = -r;
    }

    // 返回结果（保留小数点后 4 位）
    return {
        slope: parseFloat(m.toFixed(4)),         // 斜率
        intercept: parseFloat(b.toFixed(4)),     // 截距
        rSquared: parseFloat(rSquared.toFixed(4)), // R²
        correlation: Math.floor(r * 10000) / 10000   // r（相关系数）
    };
}


// 处理pdf数据
// 处理A面的数据，如果样品编号超出26条就会多生成一张A面数据（仅限没有做特殊处理的adatas数据）
export function splitDataIntoPages(data, pageSize = 26) {
    let pages = [];
    let totalPages = Math.ceil(data.length / pageSize);
    for (let i = 0; i < totalPages; i++) {
        let startIdx = i * pageSize;
        let endIdx = startIdx + pageSize;
        // 截取当前页数据并剔除 "类型" 和 "测定结果" 字段
        let pageData = data.slice(startIdx, endIdx).map(item => {
            let filteredItem = {};
            Object.keys(item).forEach(key => {
                if (key !== "类型" && !key.includes("测定结果")) {
                    filteredItem[key] = item[key];
                }
            });
            return filteredItem;
        });
        // 确保每页有 26 条数据，不足时补齐
        while (pageData.length < pageSize) {
            let emptyRow = {};
            Object.keys(pageData[0]).forEach(key => {
                emptyRow[key] = null;
            });
            pageData.push(emptyRow);
        }
        pages.push(pageData);
    }
    return pages;
}

// 处理表格头部数据，类似只有一行表头的数据可以调用
export function getHeaders(data, length) {
    // 获取字段名并排除 "类型" 和 "测定结果"
    const filteredKeys = Object.keys(data[0]).filter(key => key !== '类型' && key !== '测定结果');
    // 截取至指定长度
    return filteredKeys.slice(0, length);
}

// 处理筛选平行样编号
export function filterParallelSamples(data) {
    // 筛选出类型为 "平行样" 的数据
    const filteredData = data.filter(item => item.类型 === "平行样");

    const updatedData = filteredData.map(item => {
        // 获取所有键名包含"测定结果"的值
        const resultKeys = Object.keys(item).filter(key => key.includes("测定结果"));

        // 获取这些键对应的所有值
        const finalResult = resultKeys.map(key => item[key]).filter(Boolean); // 过滤掉无效值

        return {
            sampleNumber: item["样品编号"],
            type: item["类型"],
            finalResult: finalResult[0],
        };
    });
    return updatedData;
}

// 处理筛选质控样编号并提取括号中的内容
export function zkylSamples(data) {
    // 筛选出类型为 "质控样" 的数据
    const filteredData = data.filter(item => item.类型 === "质控样");

    const updatedData = filteredData.map(item => {
        // 使用正则表达式提取样品编号中的括号里的内容
        const sampleNumber = item["样品编号"];
        const extractedContent = sampleNumber.match(/\((.*?)\)/); // 提取括号中的内容

        // 获取所有键名包含"测定结果"的值
        const resultKeys = Object.keys(item).filter(key => key.includes("测定结果"));
        const finalResult = resultKeys.map(key => item[key]).filter(Boolean); // 过滤掉无效值

        return {
            type: item["类型"],
            finalResult: finalResult,
            extractedContent: extractedContent ? extractedContent[1] : null, // 如果找到括号内容则返回，否则返回 null
        };
    });

    return updatedData;
}

// 处理筛选空白样编号
export function kbylSamples(data) {
    // 筛选出类型为 "平行样" 的数据
    const filteredData = data.filter(item => item.类型 === "空白样");

    const updatedData = filteredData.map(item => {
        // 获取所有键名包含"测定结果"的值
        const resultKeys = Object.keys(item).filter(key => key.includes("测定结果"));
        const finalResult = resultKeys.map(key => item[key]).filter(Boolean); // 过滤掉无效值
        // 动态查找包含"试样浓度"的字段
        const concentrationKey = Object.keys(item).find(key => key.includes("试样浓度"));

        return {
            sampleNumber: item["样品编号"],
            type: item["类型"],
            hfz: item["毫伏值(mV)"] || item["吸光度"] || (concentrationKey ? item[concentrationKey] : null) ,    // 备选字段
            finalResult: finalResult[0], // 优先返回“测定结果”，没有的话返回“最终结果”
        };
    });
    return updatedData;
}


// 处理筛选空白样编号
export function qxylSamples(data) {
    // 筛选出类型为 "平行样" 的数据
    const filteredData = data.filter(item => item.类型 === "校核点");

    const updatedData = filteredData.map(item => {
        // 获取所有键名包含"测定结果"的值
        const resultKeys = Object.keys(item).filter(key => key.includes("测定结果"));

        // 获取这些键对应的所有值
        const finalResult = resultKeys.map(key => item[key]).filter(Boolean); // 过滤掉无效值

        return {
            sampleNumber: item["样品编号"],
            type: item["类型"],
            finalResult: finalResult[0],
        };
    });
    return updatedData;
}


// 处理筛选空白样编号
export function jbylSamples(data) {
    // 筛选出类型为 "加标样" 的数据
    const filteredData = data.filter(item => item.类型 === "加标样");

    const updatedData = filteredData.map(item => {
        // 获取所有键名包含"测定结果"的值
        const resultKeys = Object.keys(item).filter(key => key.includes("测定结果"));

        // 获取这些键对应的所有值
        const finalResult = resultKeys.map(key => item[key]).filter(Boolean); // 过滤掉无效值

        return {
            sampleNumber: item["样品编号"],
            type: item["类型"],
            finalResult: finalResult[0],
        };
    });
    return updatedData;
}

